package com.gagakuai.validator;


import com.gagakuai.util.StringUtils;

import java.util.concurrent.ThreadLocalRandom;

/*
 * 密码强度校验工具
 * @author flipped
 * @date 2021-12-21
 * @version 1.0.0
 */
public class PasswordValidate {

    /* 密码最小长度 */
    private static final int MIN_LENGTH = 8;

    /* 密码最大长度 */
    private static final int MAX_LENGTH = 16;

    /*
     * 数字
     */
    private static final String REG_NUMBER = ".*\\d+.*";

    /*
     * 小写字母
     */
    private static final String REG_UPPERCASE = ".*[A-Z]+.*";

    /*
     * 大写字母
     */
    private static final String REG_LOWERCASE = ".*[a-z]+.*";

    /*
     * 特殊符号(~!@#$%^&*()_+|<>,.?/:;'[]{}\)
     */
    private static final String REG_SYMBOL = ".*[~!@#$%^&*()_+|<>,.?/:;'\\[\\]{}\"]+.*";

    /*
     * 键盘字符表(小写)
     * 非shift键盘字符表
     */
    private static final char[][] CHAR_TABLE1 = new char[][]{
            {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', '\0'},
            {'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\\'},
            {'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '\0', '\0'},
            {'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/', '\0', '\0', '\0'}};

    /*
     * shift键盘的字符表
     */
    private static final char[][] CHAR_TABLE2 = new char[][]{
            {'!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '\0'},
            {'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '{', '}', '|'},
            {'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ':', '"', '\0', '\0'},
            {'z', 'x', 'c', 'v', 'b', 'n', 'm', '<', '>', '?', '\0', '\0', '\0'}};


    private static final String [] blackStrList = new String[] {"hxhk", "hx", "admin"};

    public static void main(String[] args) {
        String password = "hz128476.";
        System.out.println(checkPasswordRule(password, "dzdu"));

    }

    /*
     * 校验密码
     *
     * @param password 密码
     */
    public static boolean checkPasswordRule(String password, String username) {
        if (StringUtils.isEmpty(password) || password.length() < MIN_LENGTH || password.length() > MAX_LENGTH) {
            System.out.println("长度小于8，或大于32");
            return false;
        }

        if (password.contains(username)) {
            System.out.println("包含用户名");
            return false;
        }

        for (String str : blackStrList) {
            if (password.contains(str)) {
                System.out.println("包含通用口令");
                return false;
            }
        }


        if (isContinuousChar(password)) {
            System.out.println("包含3个及以上相同或字典连续字符");
            return false;
        }

        if (isKeyBoardContinuousChar(password)) {
            System.out.println("包含3个及以上键盘连续字符");
            return false;
        }
        int i = 0;
        if (password.matches(REG_NUMBER)) {
            i++;
        }
        if (password.matches(REG_LOWERCASE)) {
            i++;
        }
        if (password.matches(REG_UPPERCASE)) {
            i++;
        }
        if (password.matches(REG_SYMBOL)) {
            i++;
        }
        if (i < 3) {
            System.out.println("数字、小写字母、大写字母、特殊字符，至少包含三种");
            return false;
        }
        return true;
    }

    /*
     * 是否包含3个及以上相同或字典连续字符
     */
    private static boolean isContinuousChar(String password) {
        char[] chars = password.toCharArray();
        for (int i = 0; i < chars.length - 2; i++) {
            int n1 = chars[i];
            int n2 = chars[i + 1];
            int n3 = chars[i + 2];
            // 判断重复字符
            if (n1 == n2 && n1 == n3) {
                return true;
            }
            // 判断连续字符： 正序 + 倒序
            if ((n1 + 1 == n2 && n1 + 2 == n3) || (n1 - 1 == n2 && n1 - 2 == n3)) {
                return true;
            }
        }
        return false;
    }

    /*
     * 是否包含3个及以上键盘连续字符
     *
     * @param password 待匹配的字符串
     */
    private static boolean isKeyBoardContinuousChar(String password) {
        if (StringUtils.isEmpty(password)) {
            return false;
        }
        //考虑大小写，都转换成小写字母
        char[] lpStrChars = password.toLowerCase().toCharArray();

        // 获取字符串长度
        int nStrLen = lpStrChars.length;
        // 定义位置数组：row - 行，col - column 列
        int[] pRowCharPos = new int[nStrLen];
        int[] pColCharPos = new int[nStrLen];
        for (int i = 0; i < nStrLen; i++) {
            char chLower = lpStrChars[i];
            pColCharPos[i] = -1;
            // 检索在表1中的位置，构建位置数组
            for (int nRowTable1Idx = 0; nRowTable1Idx < 4; nRowTable1Idx++) {
                for (int nColTable1Idx = 0; nColTable1Idx < 13; nColTable1Idx++) {
                    if (chLower == CHAR_TABLE1[nRowTable1Idx][nColTable1Idx]) {
                        pRowCharPos[i] = nRowTable1Idx;
                        pColCharPos[i] = nColTable1Idx;
                    }
                }
            }
            // 在表1中没找到，到表二中去找，找到则continue
            if (pColCharPos[i] >= 0) {
                continue;
            }
            // 检索在表2中的位置，构建位置数组
            for (int nRowTable2Idx = 0; nRowTable2Idx < 4; nRowTable2Idx++) {
                for (int nColTable2Idx = 0; nColTable2Idx < 13; nColTable2Idx++) {
                    if (chLower == CHAR_TABLE2[nRowTable2Idx][nColTable2Idx]) {
                        pRowCharPos[i] = nRowTable2Idx;
                        pColCharPos[i] = nColTable2Idx;
                    }
                }
            }
        }

        // 匹配坐标连线
        for (int j = 1; j <= nStrLen - 2; j++) {
            //同一行
            if (pRowCharPos[j - 1] == pRowCharPos[j] && pRowCharPos[j] == pRowCharPos[j + 1]) {
                // 键盘行正向连续（asd）或者键盘行反向连续（dsa）
                if ((pColCharPos[j - 1] + 1 == pColCharPos[j] && pColCharPos[j] + 1 == pColCharPos[j + 1]) ||
                        (pColCharPos[j + 1] + 1 == pColCharPos[j] && pColCharPos[j] + 1 == pColCharPos[j - 1])) {
                    return true;
                }
            }
            //同一列
            if (pColCharPos[j - 1] == pColCharPos[j] && pColCharPos[j] == pColCharPos[j + 1]) {
                //键盘列连续（qaz）或者键盘列反向连续（zaq）
                if ((pRowCharPos[j - 1] + 1 == pRowCharPos[j] && pRowCharPos[j] + 1 == pRowCharPos[j + 1]) ||
                        (pRowCharPos[j - 1] - 1 == pRowCharPos[j] && pRowCharPos[j] - 1 == pRowCharPos[j + 1])) {
                    return true;
                }
            }
        }
        return false;
    }

    public static String generatePassword() {
        int len = ThreadLocalRandom.current().ints(MIN_LENGTH, (MAX_LENGTH + 1)).limit(1).findFirst().getAsInt();

        // 1、定义基本字符串baseStr和出参password
        String baseStr = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~!@#$%^&*()_+{}|<>?";

        StringBuilder password = null;

        // 2、使用循环来判断是否是正确的密码
        boolean flag = false;
        while (!flag) {
            // 密码重置
            password = new StringBuilder();
            // 个数计数
            int a = 0,b = 0,c = 0,d = 0;
            for (int i = 0; i < len; i++) {
                int rand = (int) (Math.random() * baseStr.length());
                password.append(baseStr.charAt(rand));
                if (rand < 10) {
                    a++;
                }
                if (10 <= rand && rand < 36) {
                    b++;
                }
                if (36 <= rand && rand < 62) {
                    c++;
                }
                if (62 <= rand) {
                    d++;
                }
            }
            // 3、判断是否是正确的密码（4类中仅一类为0，其他不为0）
            flag = (a * b * c != 0 && d == 0) || (a * b * d != 0 && c == 0)
                    || (a * c * d != 0 && b == 0) || (b * c * d != 0 && a == 0);
        }
        return password.toString();
    }
}
